package com.itheima.reggie.web;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.reggie.common.R;
import com.itheima.reggie.entity.Employee;
import com.itheima.reggie.service.EmployeeService;
import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;

@Slf4j
@RestController
@RequestMapping("/employee")
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;
    //员工登录
    @PostMapping("/login")
    public R<Employee> login(HttpServletRequest request,@RequestBody Employee employee){
        //1.接收前台传输的的password，并将登录密码进行加密处理
        String password = employee.getPassword();
        String pd = DigestUtils.md5DigestAsHex(password.getBytes());
        //2.判断登录的用户名是否正确
        //2.1构造条件构造器
        String username = employee.getUsername();
        LambdaQueryWrapper<Employee> qw = new LambdaQueryWrapper<>();
        //2.2进行用户名比对,查看用户名是否存在
        qw.eq(Employee::getUsername,username);
        Employee emp = employeeService.getOne(qw);
        //3.用户名不存在直接返回
        if (emp == null){
            return R.error("用户名不存在");
        }
        //4.验证密码，密码不对，直接返回
        if (!emp.getPassword().equals(pd)){
            return R.error("密码有误");
        }
        //5.密码验证通过后，验证状态是否禁用,禁用的话 直接返回
        if (emp.getStatus()==0){
            return R.error("员工已被禁用");
        }
        //6.所有验证通过，直接调用方法,返回响应结果，并将登录员工的id存到session中
        request.getSession().setAttribute("employee",emp.getId());
        return R.success(emp);
    }

    /*@PostMapping("/login")
    public R<Employee> login(HttpServletRequest request, @RequestBody Employee employee){
        //1.将页面提交的密码password进行md5加密处理
        String password = employee.getPassword();
        password = DigestUtils.md5DigestAsHex(password.getBytes());
        //2、根据用户名查询用户信息：  select * from user where username=?
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Employee::getUsername,employee.getUsername());

        Employee emp = employeeService.getOne(queryWrapper);
        //3.如果没有查询到则返回登录失败结果
        if (emp == null){
            return R.error("用户名错误");
        }
        //4、如果查询到了，比对密码是否正确【用户输入的密码加密后和 数据库的密码进行比对】
        //判断： 比对失败，返回登录失败
        if (!emp.getPassword().equals(password)){
            return R.error("密码错误");
        }
        //5、比对成功，说明用户名和密码是对的。
        //判断：用户是否禁用【status：0禁用  1正常】，如果是禁用，返回登录失败【员工已禁用】
        if (emp.getStatus() == 0){
            return R.error("账号已禁用");
        }
        //6、用户状态正常。登录成功。
        //6.1、存用户信息【只存用户的id】到session。
        //6.2、返回响应结果
        request.getSession().setAttribute("employee",emp.getId());
        return R.success(emp);
    }*/

    //员工退出
    @PostMapping("/logout")
    public R<String> logout(HttpServletRequest request){
        //将session中存储的id删除
        request.getSession().removeAttribute("employee");
        return R.success("退出成功");
    }
   /* @PostMapping("/logout")
    public R<String> logout(HttpServletRequest request){
        request.getSession().removeAttribute("employee");
        return R.success("退出成功");
    }*/

    //添加员工
    @PostMapping
    public R<String> add(@RequestBody Employee employee){
        //设置员工id，默认值123456
        employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
        // create_time 和 update_time 和  create_user 和 update_user 自动填充
        employeeService.save(employee);
        return R.success("添加成功");
    }
    /*@PostMapping
    public R<String> save(HttpServletRequest request,@RequestBody Employee employee){
        log.info("新增员工信息：{}",employee.toString());
        //1、检查数据，哪些是需要处理的
        //1.1: 密码使用默认的123456 ， 需要加密 DigestUtils.md5DigestAsHex
        employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
        //1.2： status 不需要处理，数据库默认是1
        //1.3： create_time 和 update_time ,设置为当前系统时间  LocalDateTime.now()
        //employee.setCreateTime(LocalDateTime.now());
        //employee.setUpdateTime(LocalDateTime.now());

        //1.4： create_user 和 update_user 创建人和修改人，应该是当前登陆人，从session中获取
        //Long empId =(Long) request.getSession().getAttribute("employee");

        //employee.setCreateUser(empId);
        //employee.setUpdateUser(empId);
        //2、调用业务层保存 employee数据

        //long id = Thread.currentThread().getId();
        //log.info("当前线程id为：{}",id);

        employeeService.save(employee);
        log.info("添加成功");
        //3.返回结果R
        return R.success("新员工添加成功");
    }*/

    //分页查询和条件查询
    @GetMapping("/page")
    public R<Page> query(int page,int pageSize,String name){
        //1.构造分页构造器
        Page pageInfo = new Page(page,pageSize);
        //2.构造条件构造器
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
        //3.过滤条件，筛选name
        queryWrapper.like(name!=null && name!="",Employee::getName,name);
        //4.添加排序条件，降序排序
        queryWrapper.orderByDesc(Employee::getUpdateTime);
        //5.执行查询，返回结果R
        employeeService.page(pageInfo,queryWrapper);
        return R.success(pageInfo);
    }
/*    @GetMapping("/page")
    public R<Page> page(int page,int pageSize,String name){
        log.info("page={},pagesize={},name={}",page,pageSize,name);
        //构造分页构造器，并将page和pagesize传入
        Page pageInfo = new Page(page,pageSize);
        //构造条件构造器，创建mp的条件查询队对象
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper();
        //添加可选参数name的过滤条件
        queryWrapper.like(StringUtils.isNotEmpty(name),Employee::getName,name);
        //添加排序条件，降序排序
        queryWrapper.orderByDesc(Employee::getUpdateTime);
        //执行查询
        employeeService.page(pageInfo,queryWrapper);
        return R.success(pageInfo);
    }*/

    //根据id查询员工信息
    @GetMapping("/{id}")
    public R<Employee> GetById(@PathVariable Long id){
        Employee employee = employeeService.getById(id);
        if (employee==null){
            return R.error("员工不存在");
        }
        return R.success(employee);
    }

    /*    @GetMapping("/{id}")
    public R<Employee> getById(@PathVariable Long id){
        Employee employee = employeeService.getById(id);
        if (employee == null){
            return R.error("用户不存在");
        }
        return R.success(employee);
    }*/


    //启用、禁用员工账号,更新员工信息
    @PutMapping
    public R<String> update(@RequestBody Employee employee){
        employeeService.updateById(employee);
        return R.success("员工信息修改成功");
    }

   /* @PutMapping
    public R<String> update(@RequestBody Employee employee){

        //从session中获取当前登入者的id
        //Long empId = (Long) request.getSession().getAttribute("employee");

        //启用、禁用时间
        //employee.setUpdateTime(LocalDateTime.now());
        //修改者，应该是当前登录的管理员，从session中获取
        //employee.setUpdateUser(empId);
        //调用修改方法
        employeeService.updateById(employee);
        //返回结果 R
        return R.success("员工信息修改成功");
    }*/



}
